home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / nihcl-30.lha / nihcl-3.0 / lib / String.c < prev    next >
C/C++ Source or Header  |  1990-05-19  |  14KB  |  622 lines
  1. /* String.c -- implementation of character strings
  2.  
  3.     THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
  4.     "UNITED STATES GOVERNMENT WORK".  IT WAS WRITTEN AS A PART OF THE
  5.     AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE.  THIS MEANS IT
  6.     CANNOT BE COPYRIGHTED.  THIS SOFTWARE IS FREELY AVAILABLE TO THE
  7.     PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
  8.     RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
  9.  
  10. Authors:
  11.     C. J. Eppich and K. E. Gorlen
  12.     Bg. 12A, Rm. 2033
  13.     Computer Systems Laboratory
  14.     Division of Computer Research and Technology
  15.     National Institutes of Health
  16.     Bethesda, Maryland 20892
  17.     Phone: (301) 496-1111
  18.     uucp: uunet!nih-csl!kgorlen
  19.     Internet: kgorlen@alw.nih.gov
  20.     December, 1987
  21.  
  22. Function:
  23.     
  24. Class String implements character string objects.  Operations provided
  25. include & (concatenation) and () (substring extraction).  Type
  26. conversions between String and char* are provided, permitting the two
  27. to be used interchangeably in many contexts.  Note also that
  28. SubStrings are not derived classes from Object.
  29.  
  30. $Log:    String.c,v $
  31.  * Revision 3.0  90/05/20  00:21:32  kgorlen
  32.  * Release for 1st edition.
  33.  * 
  34. */
  35.  
  36. #include "String.h"
  37. #include "Range.h"
  38. #include "nihclconfig.h"
  39. #include "nihclIO.h"
  40. #include <ctype.h> 
  41.  
  42. #define    THIS    String
  43. #define    BASE    Object
  44.  
  45. #define BASE_CLASSES BASE::desc()
  46. #define MEMBER_CLASSES
  47. #define VIRTUAL_BASE_CLASSES Object::desc()
  48.  
  49. DEFINE_CLASS(String,1,"$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/String.c,v 3.0 90/05/20 00:21:32 kgorlen Rel $",NULL,NULL);
  50.  
  51. extern const int NIHCL_BADCLASS, NIHCL_BADRANGE, NIHCL_INDEXRANGE, NIHCL_SUBSTRERR;
  52.  
  53. /* System-independent versions of toupper and tolower */
  54.  
  55. inline char to_upper(unsigned char c)    { return (islower(c) ? (c-'a'+'A') : c); }
  56. inline char to_lower(unsigned char c)    { return (isupper(c) ? (c-'A'+'a') : c); }
  57.  
  58.  
  59. //==== SubString functions:
  60.  
  61. /*
  62. The following compare functions were implemented because strncmp is
  63. not adequate for comparing character strings of unequal length.  For
  64. example, strncmp("abc","abcd",3) will return 0.
  65. */
  66.  
  67. int SubString::compare(const char* cs) const
  68. /*
  69. Return integer greater than, equal to, or less than 0, according as
  70. this SubString is lexicographically greater than, equal to, or less
  71. than cs.
  72. */
  73. {
  74.     int cl = strlen(cs);
  75.     int result = strncmp(sp,cs,sl);
  76.     if (result != 0 || sl == cl) return result;
  77.     return (sl>cl ? 1 : -1);
  78. }
  79.  
  80. int SubString::compare(const String& s) const
  81. /*
  82. Return integer greater than, equal to, or less than 0, according as
  83. this SubString is lexicographically greater than, equal to, or less
  84. than s.
  85. */
  86. {
  87.     int result = strncmp(sp,s.p,sl);
  88.     if (result != 0 || sl == s.len) return result;
  89.     return (sl>s.len ? 1 : -1);
  90. }
  91.  
  92. int SubString::compare(const SubString& ss) const
  93. /*
  94. Return integer greater than, equal to, or less than 0, according as
  95. this SubString is lexicographically greater than, equal to, or less
  96. than SubString ss.
  97. */
  98. {
  99.     int result = strncmp(sp,ss.sp,MIN(sl,ss.sl));
  100.     if (result != 0 || sl == ss.sl) return result;
  101.     return (sl>ss.sl ? 1 : -1);
  102. }
  103.  
  104. void SubString::dumpOn(ostream& strm) const
  105. // Dump this SubString on output stream strm.
  106. {
  107.     strm << String(*this);
  108.     strm << '[' << st->p << '(' << position() << ',' << sl << ")]";
  109. }
  110.  
  111. void SubString::printOn(ostream& strm) const
  112. // Print this SubString on output stream strm.
  113. {
  114.     strm << String(*this);
  115. }
  116.  
  117. void SubString::operator=(const String& s)
  118. {
  119.     if (sl == s.length()) strncpy(sp,s.p,sl);
  120.     else replace(s.p,s.len);
  121. }
  122.  
  123. void SubString::operator=(const SubString& ss)
  124. {
  125.     if (sl == ss.sl) strncpy(sp,ss.sp,sl);
  126.     else replace(ss.sp,ss.sl);
  127. }
  128.  
  129. void SubString::operator=(const char* cs)
  130. {
  131.     int cslen = strlen(cs);
  132.     if (sl == cslen) strncpy(sp,cs,sl);
  133.     else replace(cs,cslen);
  134. }
  135.  
  136. void SubString::replace(const char* src, unsigned srclen)
  137. // Replace this SubString with the argument string
  138. // Terminology:
  139. //    head: portion of destination string before this SubString
  140. //    tail: portion of destination string after this SubString
  141. {
  142. #ifdef DEBUG
  143. cerr << "replacing " << *this << " by ";
  144. cerr.write(src, srclen);
  145. cerr << " ...\n";
  146. #endif
  147.     bool overlap = NO;    // src overlaps destination String
  148.     int tailDelta = 0;    // amount to adjust for tail movement
  149.     char* srcbuf = 0;    // buffer to hold src if it overlaps SubString
  150. // src overlap destination String?
  151.     if (src >= st->p && src <= st->p+st->len) {
  152.         overlap = YES;    // src overlaps destination String
  153. // src overlap only tail of destination String?
  154.         if (src >= sp+sl) tailDelta = srclen-sl;
  155.         else {        
  156. // src overlap this SubString?
  157.             if (src+srclen > sp) {    // move src to buffer
  158.                 srcbuf = new char[srclen];
  159.                 strncpy(srcbuf,src,srclen);
  160.                 src = srcbuf;
  161.                 overlap = NO;    // no overlap now
  162.             }
  163.         }
  164.     }
  165. #ifdef DEBUG
  166. cerr << "overlap=" << overlap << "  tailDelta=" << tailDelta << "  srcbuf=" << (int)srcbuf << '\n';
  167. #endif
  168.     if (srclen+st->len >= sl+st->alloc) {    // need to make String bigger
  169.         char* p = st->p;
  170.         st->alloc = st->len+srclen-sl+DEFAULT_STRING_EXTRA+1;
  171.         st->p = (char*)realloc(st->p, st->alloc);
  172.         sp += st->p-p;
  173.         if (overlap) src += st->p-p;
  174. #ifdef DEBUG
  175. cerr << "realloc(" << st->alloc << ")  " << *this << '\n';
  176. #endif
  177.     }
  178.     if (sl > srclen) {    // shift tail down
  179.         register const char* p = sp+sl;
  180.         register char* q = sp+srclen;
  181.         while (*q++ = *p++);
  182.     }
  183.     else {            // shift tail up
  184.         register const char* p = st->p+st->len;
  185.         register char* q = (char*)p+srclen-sl;
  186.         register unsigned n = p-(sp+sl)+1;
  187.         while (n--) *q-- = *p--;
  188.     }
  189.     src += tailDelta;
  190.     st->len += srclen-sl;
  191. #ifdef DEBUG
  192. cerr << "target " << *this << " source ";
  193. cerr.write(src, srclen);
  194. cerr << endl;
  195. #endif
  196.     strncpy(sp,src,srclen);        // insert src into destination
  197.     if (srcbuf) free(srcbuf);
  198. #ifdef DEBUG
  199. cerr << "... result: " << *this << '\n';
  200. #endif
  201. }
  202.  
  203. String SubString::operator&(const SubString& ss) const
  204. {
  205.     String t(sl + ss.sl);
  206.     strncpy (t.p, sp, sl);
  207.     strncpy (&(t.p[sl]), ss.sp, ss.sl);
  208.     t.len = sl + ss.sl;
  209.     t.p[t.len] = '\0';
  210.     return t;
  211. }
  212.  
  213. String SubString::operator&(const String& s) const
  214. {
  215.     String t(sl + s.alloc -1);
  216.     strncpy(t.p, sp, sl);
  217.     strcpy(&(t.p[sl]), s.p);
  218.     t.len = sl + s.len;
  219.     return t;
  220. }
  221.  
  222. String SubString::operator&(const char* cs) const
  223. {
  224.     int cslen = strlen(cs);
  225.     String t(sl + cslen);
  226.     strncpy(t.p,sp,sl);
  227.     strcpy(&(t.p[sl]),cs);
  228.     t.len = sl + cslen;
  229.     return t;
  230. }
  231.  
  232. String operator&(const char* cs, const SubString& ss)
  233. {
  234.     unsigned cslen = strlen(cs);
  235.     String t(cslen + ss.sl);
  236.     strcpy(t.p,cs);
  237.     strncpy(&(t.p[cslen]),ss.sp,ss.sl);
  238.     t.len = cslen + ss.sl;
  239.     t.p[t.len] = '\0';
  240.     return t;
  241. }
  242.  
  243. void SubString::checkSubStr() const
  244. // check for legal SubString
  245. {
  246.     unsigned pos = position();
  247.     unsigned len = st->len;
  248.     if (pos+sl <= len) return;
  249.     if (sl == 0 && pos == len) return;
  250.     setError(NIHCL_SUBSTRERR,DEFAULT,st,st->className(),pos,sl);
  251. }
  252.  
  253. //==== String Private functions:
  254.  
  255. void String::indexRangeErr() const
  256. {
  257.     setError(NIHCL_INDEXRANGE,DEFAULT,this,className());
  258. }
  259.  
  260. //==== String Constructors:
  261.  
  262. String::String(const char& c, unsigned l, unsigned extra)
  263. {
  264.     len = l;
  265.     alloc = len + extra + 1;
  266.     p = (char*)malloc(alloc);
  267.     register unsigned i=len;
  268.     p[i] = '\0';
  269.     while (i > 0) p[--i] = c;
  270. }
  271.  
  272. String::String()
  273. {
  274.     len = 0;
  275.     alloc = DEFAULT_STRING_EXTRA + 1;
  276.     p = (char*)malloc(alloc);
  277.     *p = '\0';
  278. }
  279.  
  280. String::String(unsigned extra)
  281. {
  282.     len = 0;
  283.     alloc = extra + 1;
  284.     p = (char*)malloc(alloc);
  285.     *p = '\0';
  286. }
  287.  
  288. String::String(const char* cs)
  289. { 
  290.     len = strlen(cs);
  291.     alloc = len + DEFAULT_STRING_EXTRA + 1;
  292.     p = (char*)malloc(alloc);
  293.       strcpy(p,cs); 
  294. }
  295.  
  296. String::String(const char* cs, unsigned extra)
  297. { 
  298.     len = strlen(cs);
  299.     alloc = len + extra + 1;
  300.     p = (char*)malloc(alloc);
  301.       strcpy(p,cs); 
  302. }
  303.  
  304. String::String(const String& s)
  305. {
  306.     len = s.len;
  307.     alloc = len + DEFAULT_STRING_EXTRA + 1;
  308.     p = (char*)malloc(alloc);
  309.     strcpy (p,s.p);
  310. }
  311.  
  312. String::String(const String& s, unsigned extra)
  313. {
  314.     len = s.len;
  315.     alloc = len + extra + 1;
  316.     p = (char*)malloc(alloc);
  317.     strcpy(p,s.p);
  318. }
  319.  
  320. String::String(const SubString& ss)
  321. {
  322.     len = ss.sl;
  323.     alloc = len + DEFAULT_STRING_EXTRA + 1;
  324.     p = (char*)malloc(alloc);
  325.     strncpy(p,ss.sp,ss.sl);
  326.     p[len] = '\0';
  327. }
  328.  
  329. String::String(const SubString& ss, unsigned extra)
  330. {
  331.     len = ss.sl;
  332.     alloc = len + extra + 1;
  333.     p = (char*)malloc(alloc);
  334.     strncpy(p,ss.sp,ss.sl);
  335.     p[len] = '\0';
  336. }
  337.  
  338. String::~String()    { free(p); }
  339.  
  340. //==== Operators:
  341.  
  342. SubString String::operator()(const Range& r)
  343. {
  344.     if (r.valid()) return SubString(*this,r.firstIndex(),r.length());
  345.     else  setError(NIHCL_BADRANGE,DEFAULT,this,className(),"operator()",r.firstIndex(),r.length());
  346. }
  347.  
  348. const SubString String::operator()(const Range& r) const
  349. {
  350.     if (r.valid()) return SubString(*this,r.firstIndex(),r.length());
  351.     else  setError(NIHCL_BADRANGE,DEFAULT,this,className(),"operator()",r.firstIndex(),r.length());
  352. }
  353.  
  354. void String::operator=(const String& s)
  355. {
  356.     if (p == s.p) return;
  357.     len = s.len;
  358.     if (len >= alloc) {
  359.         free(p);
  360.         p = (char*)malloc(alloc = s.alloc);
  361.     }
  362.     strcpy(p,s.p);
  363. }
  364.  
  365. void String::operator=(const SubString& ss)
  366. {
  367.     len = ss.sl;
  368.     if (this == ss.st) {        // s = s(pos,len)
  369.         if (ss.sp == p) {    // s = s(0,len)
  370.             p[len] = '\0';
  371.             return;
  372.         }
  373.         register const char* src = ss.sp;
  374.         register char* dst = p;
  375.         register unsigned n = len;
  376.         while (n--) *dst++ = *src++;
  377.         *dst = '\0';
  378.         return;
  379.     }
  380.     else if (len >= alloc) {
  381.         alloc = ss.sl + DEFAULT_STRING_EXTRA + 1;
  382.         free(p);
  383.         p = (char*)malloc(alloc);
  384.     }
  385.     strncpy(p, ss.sp, ss.sl);
  386.     p[len] = '\0';
  387. }
  388.  
  389. void String::operator=(const char* cs)
  390. {
  391.     len = strlen(cs);
  392.     if (len >= alloc) {
  393.         alloc = len + DEFAULT_STRING_EXTRA + 1;
  394.         free(p);
  395.         p = (char*)malloc(alloc);
  396.     }    
  397.     strcpy(p,cs);
  398. }
  399.  
  400. String String::operator&(const String& s) const
  401. {
  402.     String t(len+s.len);
  403.     strcpy(t.p,p);
  404.     strcpy(&(t.p[len]), s.p);
  405.     t.len = len+s.len;
  406.     return t;
  407. }
  408.  
  409. String String::operator&(const SubString& ss) const
  410. {
  411.     String t(len+ss.sl);
  412.     strcpy(t.p,p);
  413.     strncpy(&(t.p[len]), ss.sp, ss.sl);
  414.     t.len = len+ss.sl;
  415.     t.p[t.len] = '\0';
  416.     return t;
  417. }
  418.  
  419. String String::operator&(const char* cs) const
  420. {
  421.     unsigned cslen = strlen(cs);
  422.     String t(len+cslen);
  423.     strcpy (t.p,p);
  424.     strcpy (&(t.p[len]), cs);
  425.     t.len = len+cslen;
  426.     return t;
  427. }
  428.  
  429. String operator&(const char* cs, const String& s)
  430. {
  431.     int cslen=strlen(cs);
  432.     String t(cslen + s.len);
  433.     strcpy(t.p,cs);
  434.     strcpy(&(t.p[cslen]),s.p);
  435.     t.len = cslen + s.len;
  436.     return t;
  437. }
  438.  
  439. String& String::operator&=(const String& s)
  440. // Concatenate a String with another
  441. {
  442.     if (alloc <= len + s.len) {
  443.         alloc += s.len + DEFAULT_STRING_EXTRA;
  444.         p = (char*)realloc(p, alloc);
  445.     }
  446.     strcpy(&p[len],s.p);
  447.     len += s.len;
  448.     return *this;
  449. }    
  450.  
  451. String& String::operator&=(const SubString& ss)
  452. {
  453.     if (alloc <= len + ss.sl) {
  454.         alloc += ss.sl + DEFAULT_STRING_EXTRA;
  455.         if (this == ss.st) {    // s &= s(pos,len)
  456.             char* t = p;
  457.             p = (char*)malloc(alloc);
  458.             strcpy(p,t);
  459.             strncpy(&(p[len]),ss.sp,ss.sl);
  460.             free(t);
  461.             len += ss.sl;
  462.             p[len] = '\0';
  463.             return *this;
  464.         }
  465.         else p = (char*)realloc(p,alloc);
  466.     }        
  467.     strncpy(&(p[len]),ss.sp,ss.sl);
  468.     len += ss.sl;
  469.     p[len] = '\0';
  470.     return *this;
  471. }
  472.  
  473. String& String::operator&=(const char* cs)
  474. {
  475.     int cslen = strlen(cs);
  476.     if (alloc <= len + cslen) {
  477.         alloc += cslen + DEFAULT_STRING_EXTRA;
  478.         p = (char*)realloc(p,alloc);
  479.     }
  480.     strcpy(&(p[len]),cs);
  481.     len += cslen;
  482.     return *this;
  483. }
  484.  
  485. void String::toAscii()
  486. {
  487.     register unsigned i = len;
  488.     register char* q = p;
  489.     while (i--) { *q = toascii(*q); q++; }
  490. }
  491.  
  492. void String::toLower()
  493. {
  494.     register unsigned i = len;
  495.     register char* q = p;
  496.     while (i--) { *q = to_lower(*q); q++; }
  497. }
  498.  
  499. void String::toUpper()
  500. {
  501.     register unsigned i = len;
  502.     register char* q = p;
  503.     while (i--) { *q = to_upper(*q); q++; }
  504. }
  505.  
  506. int String::compare(const Object& ob) const
  507. {
  508.     assertArgClass(ob,classDesc,"compare");
  509.     return strcmp(p,castdown(ob).p);
  510. }
  511.  
  512. void String::deepenShallowCopy() {}
  513.  
  514. static union char_mask {
  515.     unsigned in[sizeof(int)];
  516.     char ch[sizeof(int)*sizeof(int)];
  517.     char_mask();
  518. } mask;
  519.  
  520. char_mask::char_mask()
  521. {
  522.     for (register unsigned i=0; i<sizeof(int); i++) {
  523.         for (register unsigned j=0; j<sizeof(int); j++) ch[sizeof(int)*i+j] = j<i ? 0xff : 0;
  524.     }
  525. }
  526.  
  527. bool String::operator==(const String& s) const
  528. {
  529.     if (len != s.len) return NO;
  530.     register unsigned i = div_sizeof_int(len);
  531.     register const unsigned* q = (unsigned*)p;
  532.     register const unsigned* r = (unsigned*)s.p;
  533.     while (i--) if (*q++ != *r++) return NO;
  534.     if ((i = mod_sizeof_int(len)) != 0)
  535.         if ((*q & mask.in[i]) != (*r & mask.in[i])) return NO;
  536.     return YES;
  537. }
  538.  
  539. unsigned String::hash() const
  540. {
  541.     register unsigned h = len;
  542.     register unsigned i = div_sizeof_int(len);
  543.     register unsigned* q = (unsigned*)p;
  544.     while (i--) h ^= *q++;
  545.     if ((i = mod_sizeof_int(len)) != 0)
  546.         h ^= *q & mask.in[i];
  547.     return h;
  548. }
  549.  
  550. bool String::isEqual(const Object& a) const
  551. {
  552.     return a.isSpecies(classDesc) && *this==castdown(a);
  553. }
  554.  
  555. void String::printOn(ostream& strm) const    { strm << p; }
  556.  
  557. void String::scanFrom(istream& strm)
  558. //    Read next line of input from strm into this String.
  559. {
  560.     ostream* os = strm.tie((ostream*)0);
  561.     if (os != 0) {
  562.         os->flush();
  563.         strm.tie(os);
  564.     }
  565.     char c;
  566.     strm.get(c);
  567.     if (c != '\n') strm.putback(c);
  568.     char temp[513];
  569.     strm.get(temp,513);
  570.     *this = String(temp);
  571. }
  572.  
  573. unsigned String::reSize(unsigned new_capacity)
  574. {
  575.     if (new_capacity < len) new_capacity = len;
  576.     if (alloc != new_capacity+1) {
  577.         p = (char*)realloc(p,alloc = new_capacity+1);
  578.     }
  579.     return alloc - 1;
  580. }
  581.  
  582. unsigned String::size() const        { return len; }
  583.  
  584. unsigned String::capacity() const    { return alloc - 1; }
  585.  
  586. const Class* String::species() const
  587. {
  588.     return String::desc();
  589. }
  590.  
  591. String::String(OIOifd& fd)
  592.     : BASE(fd)
  593. {
  594.     fd >> len >> alloc;
  595.     p = (char*)malloc(alloc);
  596.     fd.get(p,len+1);
  597. }
  598.  
  599. void String::storer(OIOofd& fd) const
  600. {
  601.     BASE::storer(fd);
  602.     fd << len << alloc;
  603.     fd.put(p,len+1);    // store terminating null character
  604. }
  605.  
  606. String::String(OIOin& strm)
  607.     : BASE(strm)
  608. {
  609.     strm >> len >> alloc;
  610.     p = (char*)malloc(alloc);
  611.     strm.getCString(p,len+1);
  612. }
  613.  
  614. void String::storer(OIOout& strm) const
  615. {
  616.     BASE::storer(strm);
  617.     strm << len << alloc;
  618.     strm.putCString(p);
  619. }
  620.  
  621.  
  622.